package gomz.pres.admin;

import gomz.GlobalRes;
import gomz.pres.MUser;
import gomz.pres.ModelMain;
import gomz.res.Category;
import gomz.res.Hexagram;
import gomz.res.HexagramCore;
import gomz.res.Question;
import gomz.res.QuestionCore;
import gomz.res.User;
import gomz.res.UserCore;
import java.io.BufferedReader;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.StringTokenizer;
import word.api.interfaces.IDocument;
import word.w2004.Document2004;
import word.w2004.elements.BreakLine;
import word.w2004.elements.Heading1;
import word.w2004.elements.Heading2;
import word.w2004.elements.Image;
import word.w2004.elements.PageBreak;
import word.w2004.elements.Paragraph;
import word.w2004.elements.Table;
import word.w2004.elements.tableElements.TableEle;

/**
 * Diese Klasse verwaltet die Inhalte fuer das UI GUIVerwaltung und beinhaltet deren Logik
 * @author Murillo
 * @author Schatzmann
 * @author Dilji
 */
public class MVerwaltung extends ModelMain{
	// ********************************************************************************
	// Variablen
	// ********************************************************************************
	private ArrayList<UserCore> allUsers;		//Liste mit allen Benutzernkernen
	private ArrayList<HexagramCore> allHex;		//Liste mit allen Hexagramkernen
	private User userUsed;						//Der Benutzer, welcher aktuell bearbeitet wird
	private MUser mUser = new MUser();			//Model des Users um es wieder zu verwenden
	private boolean activUserSaved = false;		//Boolean ob die Angaben des angemeldeten benutzer veraendert wurde
	
	// ********************************************************************************
	// Getter/Setter
	// ********************************************************************************
	public boolean isActivUserSaved() {
		return activUserSaved;
	}

	public void setActivUserSaved(boolean activUserSaved) {
		this.activUserSaved = activUserSaved;
	}
	
	public User getUserUsed() {
		return userUsed;
	}

	public void setUserUsed(User userUsed) {
		this.userUsed = userUsed;
	}
	
	public MUser getmUser() {
		return mUser;
	}

	public void setmUser(MUser mUser) {
		this.mUser = mUser;
	}

	public ArrayList<UserCore> getAllUsers() {
		return allUsers;
	}

	public void setAllUsers(ArrayList<UserCore> allUsers) {
		this.allUsers = allUsers;
	}

	public ArrayList<HexagramCore> getAllHex() {
		return allHex;
	}

	public void setAllHex(ArrayList<HexagramCore> allHex) {
		this.allHex = allHex;
	}
	
	// ********************************************************************************
	// Konstruktor
	// ********************************************************************************
	/**
	 * Konstruktor des Models fuer die Verwaltung
	 * @param categories ArrayListe der zu verwendenden Kategorien
	 * @param questionCoresAll ArrayListe mit den zu verwendenden Fragestellungen (QuestionCores)
	 */
	public MVerwaltung(ArrayList<Category> categories, ArrayList<QuestionCore> questionCoresAll) {
		super.setCategories(categories);
		super.setQuestionCoresAll(questionCoresAll);
		loadData();
	}

	// ********************************************************************************
	// Methoden
	// ********************************************************************************
	
	/**
	 * Diese Methode hohlt die benoetigten Daten vom Server und von MQuestion
	 * @return Boolean ob die Daten geladen werden konnte
	 */
	public boolean loadData(){
		boolean re = true;
		
		//Falls der Benutzer Administrationsrechte, werden alle Benutzer geladen
		if (GlobalRes.getActivUser().isAdmin()){
			allUsers = con.userCoreGetAll();
			if(allUsers == null){
				re = false;
				allUsers = new ArrayList<UserCore>();
			}
			else{
				//Den Aktiven Benutzer in der Liste setzten (Pointer)
				for(UserCore uc : allUsers){
					if (uc.getId() == GlobalRes.getActivUser().getId()){
						uc = GlobalRes.getActivUser();
					}
				}
			}
		}
		
		//Die Titel aller Hexagramme werden gehohlt
		allHex = con.hexagramCoreGetAll();
		if (allHex == null){
			allHex = new ArrayList<HexagramCore>();
			re = false;
		}
		if (questionCoresAll != null) questionCoresUsed = questionCoresAll;
		
		return (re);
	}
	
	/**
	 * Diese Methode loescht einen Benutzer
	 * @param indexToDel Index aus der List des zu loeschenden Benutzers
	 * @return Boolean ob die Loeschung durchgefuehrt werden konnte
	 */
	public boolean delUser(int indexToDel){
		boolean re = false;
		re = con.userDelete(allUsers.get(indexToDel).getId());
		if (re) allUsers.remove(indexToDel);
		return (re);
	}
	
	/**
	 * Diese Methode hohlt den Benutzer, dessen ID uebergeben wurde, vom Server. Falls der Benutzer nicht
	 * gehohlt werden konnte, wird NULL zurueckgegeben.
	 * @param indexToLoad Index des zu hohlenden Benutzers (aus der Liste)
	 * @return der gewuenschte Benutzer bzw. NULL
	 */
	public User loadUser(int indexToLoad){
		User re = con.userGet(allUsers.get(indexToLoad).getId());
		return (re);
	}
	
	/**
	 * Diese Methode speichert einen Benutzer auf dem Server.
	 * @param userId ID des Benutzers, falls vorhanden. Sonst 0
	 * @param userName Benutzername des Benutzers
	 * @param password Passwort des Benutzers
	 * @param firstName Vorname des Benutzer
	 * @param lastName Nachname des Benutzers
	 * @param mail Emailadresse des Benutzers
	 * @param lang Spracheinstellung des Benutzers
	 * @param isAdmin Boolean ob der Benutzer ein Admin sein soll
	 * @return Boolean ob die Speicherung erfolgreich durchgefuehrt werden konnte
	 */
	public boolean saveUser(int userId, String userName, char[] password, String firstName, String lastName, String mail, int lang, boolean isAdmin){
		boolean re = false;
		int indexToSave = 0;
		//Index des Users aus der Liste mit den UserCores hohlen
		for (UserCore uc : allUsers){
			if(userId == uc.getId()){
				indexToSave = allUsers.indexOf(uc);
				break;
			}
		}
		re = saveUser(userId, userName, password, firstName, lastName, mail, lang, isAdmin, indexToSave);
		return (re);
	}
	
	/**
	 * Diese Methode speichert einen Benutzer auf dem Server.
	 * @param userId ID des Benutzers, falls vorhanden. Sonst 0
	 * @param userName Benutzername des Benutzers
	 * @param password Passwort des Benutzers
	 * @param firstName Vorname des Benutzer
	 * @param lastName Nachname des Benutzers
	 * @param mail Emailadresse des Benutzers
	 * @param lang Spracheinstellung des Benutzers
	 * @param isAdmin Boolean ob der Benutzer ein Admin sein soll
	 * @param indexToSave Index des Benutzers in der Liste
	 * @return Boolean ob die Speicherung erfolgreich durchgefuehrt werden konnte
	 */
	public boolean saveUser(int userId, String userName, char[] password, String firstName, String lastName, String mail, int lang, boolean isAdmin, int indexToSave){
		User re = mUser.doSave(userId, userName, password, firstName, lastName, mail, lang, isAdmin);
		
		if (re != null){
			setUserUsed(re);
			//Daten des activUsers neu setzten
			if (getUserUsed().getId() == GlobalRes.getActivUser().getId()){
				GlobalRes.getActivUser().seteMail(getUserUsed().geteMail());
				GlobalRes.getActivUser().setLanguage(getUserUsed().getLanguage());
				GlobalRes.getActivUser().setNachname(getUserUsed().getNachname());
				GlobalRes.getActivUser().setUsername(getUserUsed().getUsername());
				GlobalRes.getActivUser().setVorname(getUserUsed().getVorname());
				setActivUserSaved(true);
			}
			
			//Falls kein neuer User, Daten in der Liste speichern, sonst User der Liste hinzufuegen
			if(userId == 0){
				UserCore uc = new UserCore();
				uc.setId(re.getId());
				uc.setUsername(re.getUsername());
				getAllUsers().add(uc);
			}
			else{
				UserCore updateUser = getAllUsers().get(indexToSave);
				updateUser.setUsername(userName);
			}
		}
		if (re!=null)	return(true);
		else 			return(false);
	}
	
	/**
	 * Erstellt eine Liste mit den Benutzernamen aller lokal vorhandenert Benutzer 
	 * @return String[] Liste der Benutzernamen der lokal vorhandenen Benutzern
	 */
	public String[] getUserList(){
		String[] re = {""};
		//nur wenn der angemeldete Benutzer Administrationsrechte hat
		if(GlobalRes.getActivUser().isAdmin()){
			re = new String[allUsers.size()];
			
			for(int i = 0; i < re.length; i++){
				re[i] = allUsers.get(i).getUsername();
			}
		}
		return(re);
	}
	
	/**
	 * Diese Methode Ladet ein Hexagramm vom Server und speichert es im Model in der Variable hexagram
	 * @param hexId Id des zu hohlenden Hexagramms
	 */
	public void loadHexagram(int hexId){
		Hexagram hex  = con.hexagramGet(hexId);
		if (hex != null)	setHexagram(hex);
	}
	
	/**
	 * Erstellt eine Liste mit allen Hexagrammnamen
	 * @return String[] Liste aller Hexagrammnamen
	 */
	public String[] getHexagramList(){
		
		String[] re = new String[allHex.size()];
		
		for(int i = 0; i < re.length; i++){
			re[i] = allHex.get(i).getName();
		}
		return(re);
	}
	
	
         /**
         * @author Schatzmann
         * Exportiert Fragen in ein oder Mehrere .doc Files
         * @param exportPath Pfad wo das/die .doc Files gespeichert werden
         * @param questionIndeces IntArray mit den ausgewählten Questions
         * @param manyFiles true heisst jede Fragestellung in ein eigenes .doc
         */
	public boolean exportQuestionToDoc(File exportPath, int[] questionIndeces, boolean manyFiles){
                //rueckgabewert answer
                boolean answer = false;
                
		//lese alle Selected QuestionCores aus und speichere Sie in der ArrayList<QuestionCore> selectedQuestionCores
		ArrayList<QuestionCore> selectedQuestionCores = new ArrayList<QuestionCore>();
		for(int selectedIndex : questionIndeces){
			selectedQuestionCores.add(questionCoresUsed.get(selectedIndex));
		}
                
                //myDoc: neues Document erstellen
                IDocument myDoc = new Document2004();
                //Formatierung von myDoc ist UTF_8
                myDoc.encoding(Document2004.Encoding.UTF_8);
                
                //*********Kopf und FUSSZEILE DES DOC*****************
                //Header: "Yi Ching Export vom dd.MM.yyyy"
                myDoc.getHeader().addEle(Paragraph.with("Yi Ching Export vom: " + new SimpleDateFormat("dd.MM.yyyy").format(new Date()) ).create());
                //Footer: Nummer der Seite
                //leerer Footer damit PageNumber hineingeschrieben werden kann
                myDoc.getFooter().addEle(Paragraph.with("").create());  
                myDoc.getFooter().showPageNumber(true);
                //**********************************************************
                
                //hole für jedes selectedQuestionCore die komplette Question und speichere diese im Question[] questionArray
                //füge danach die einzelnen Werte in das document ein
                //überprüfe danach ob alle Fragestellngen in ein oder mehrere Dokumente gespeichert werden sollen
                //falls manyFiles = true: schliesse das dokument ab und setze es zurück, beginne dann die for schleife von neuem mit der nächsten Fragestellung
                Question[] questionArray = new Question[selectedQuestionCores.size()];
                for(int i=0 ; i<questionArray.length; i++){
                    questionArray[i] = con.questionGet(selectedQuestionCores.get(i).getId());
                    
                    //Seitenumbruch falls nicht erste Question und nicht manyFiles
                    if(i!=0){
                        if(!manyFiles){
                            myDoc.addEle(PageBreak.create());
                        }
                    }
                    

                    
                    //*********INHALT DES DOC*****************
                    //Titel Title
                    myDoc.addEle(Heading1.with("Titel: " + questionArray[i].getTitle()).create());
                    //Paragraph User
                    myDoc.addEle(Paragraph.with("Ersteller: "+ questionArray[i].getUser().getUsername()).create());
                    //Paragraph Created
                    myDoc.addEle(Paragraph.with("Erstellungsdatum: " + questionArray[i].getCreateDateFormated()).create());
                     
                    //Titel Kategorie
                    myDoc.addEle(Heading2.with("Kategorien:").create());
                    //Paragraph Kategorie INHALT
                    String kategorien = new String();
                    for(int y=0 ; y<questionArray[i].getCat().size(); y++){
                        kategorien = kategorien  +  questionArray[i].getCat().get(y).getName() + ", ";
                    
                    }
                    //Paragraph Kategorien
                    myDoc.addEle(Paragraph.with(kategorien));
                    
                    //Titel Frage
                    myDoc.addEle(Heading2.with("Frage").create());
                    //Paragraph Question
                    myDoc.addEle(Paragraph.with(questionArray[i].getQuestion()).create());
                    
                    //Titel Analysis
                    myDoc.addEle(Heading2.with("Analysis").create());
                    //Paragraph Analysis
                    myDoc.addEle(Paragraph.with(questionArray[i].getAnalysis()).create());
                    
                    //Titel Synthese
                    myDoc.addEle(Heading2.with("Synthese").create());
                    //Paragraph Synthese
                    myDoc.addEle(Paragraph.with(questionArray[i].getSynthesis()).create());
                    
                    //Titel Feeback
                    myDoc.addEle(Heading2.with("Feeback").create());
                    //Paragraph Feeback
                    myDoc.addEle(Paragraph.with(questionArray[i].getFeedback()).create());


                    
                    //Titel Linien
                    myDoc.addEle(Heading2.with("Linien").create());
                    //ein Zeilenumbruch
                    myDoc.addEle(BreakLine.times(1).create());
                    
                    //Hexagramm Zahlen und Hexagramm Bilder 
                    int[] lineArray = questionArray[i].getLines();
                    //Die 6 Linien
                    String[] stringArray = new String[]{"Eintritt: ","Praefekt: ","Durchgang: ","Minister: ","Souveraen/Herrscher: ","Ausgang: "};
                    Table tbl = new Table();
                    
                    
                    //for schleife in umgekehrter reihenfolge, da [0] die unterste Hexagramm linie ist
                    for(int z=5 ; z>=0; z--){
                        //myDoc.addEle(Paragraph.with(Integer.toString(lineArray[z])));
                        //Bild (Linienart) ermitteln und einfügen
                        switch(lineArray[z]){
                            case 6:
                                    //tbl.addTableEle(TableEle.TD, Integer.toString(lineArray[z]));
                                    tbl.addTableEle(TableEle.TD, stringArray[z]  + "Alter Yin (6) ", Image.from_CLASSPATH("/gomz/img/line3.png").setHeight("20").setWidth("124").getContent());
                                    //myDoc.addEle(Image.from_CLASSPATH("/gomz/img/line3.png").getContent()); //altes Yin (unterbrochene Linie mit X)
                                    break;
                            case 7:
                                    tbl.addTableEle(TableEle.TD, stringArray[z] + " Junger Yang (7) ", Image.from_CLASSPATH("/gomz/img/line1.png").setHeight("20").setWidth("124").getContent());
                                    //myDoc.addEle(Image.from_CLASSPATH("/gomz/img/line1.png")); //junges Yang (durchgezogene Linie)
                                    break;
                            case 8:
                                    tbl.addTableEle(TableEle.TD, stringArray[z]  + "Junger Yin (8) ", Image.from_CLASSPATH("/gomz/img/line2.png").setHeight("20").setWidth("124").getContent());
                                    //myDoc.addEle(Image.from_CLASSPATH("/gomz/img/line2.png")); //junges Yin (unterbrochene Linie)
                                    break;
                            case 9:
                                    tbl.addTableEle(TableEle.TD, stringArray[z]  + "Alter Jang (9) ", Image.from_CLASSPATH("/gomz/img/line4.png").setHeight("20").setWidth("124").getContent());
                                    //myDoc.addEle(Image.from_CLASSPATH("/gomz/img/line4.png")); //altes Yang (durchgezogene Linie mit kreis)
                                    break;
                        }
                        
                        
                        
                    }
                    //Tabelle mit den 6 Linien hinzufügen
                    myDoc.addEle(tbl);
                    
                    //ein Zeilenumbruch
                    myDoc.addEle(BreakLine.times(1).create());
                    
                    //EXPORT HEXAGRAMMTITEL UND ANDERE HEXAGRAMME
                    //Titel Hexagramme
                    myDoc.addEle(Heading2.with("Hexagramme").create());
                    // Question Hexagram[12] hex -> Kontext, Perspektiv, Komplementaer, Wende, Nuklear, Fuxi, Linien 1-6
                    Hexagram[] hex = questionArray[i].getHex();
                    myDoc.addEle(Paragraph.with("Kontext: " + hex[0].getName()).create());
                    myDoc.addEle(Paragraph.with("Perspektiv: " + hex[1].getName()).create());
                    myDoc.addEle(Paragraph.with("Komplementaer: " + hex[2].getName()).create());
                    myDoc.addEle(Paragraph.with("Wende: " + hex[3].getName()).create());
                    myDoc.addEle(Paragraph.with("Nuklear: " + hex[4].getName()).create());
                    myDoc.addEle(Paragraph.with("Fuxi: " + hex[5].getName()).create());
                    myDoc.addEle(Paragraph.with("Linie 1: " + hex[6].getName()).create());
                    myDoc.addEle(Paragraph.with("Linie 2: " + hex[7].getName()).create());
                    myDoc.addEle(Paragraph.with("Linie 3: " + hex[8].getName()).create());
                    myDoc.addEle(Paragraph.with("Linie 4: " + hex[9].getName()).create());
                    myDoc.addEle(Paragraph.with("Linie 5: " + hex[10].getName()).create());
                    myDoc.addEle(Paragraph.with("Linie 6: " + hex[11].getName()).create());
                    //*********ENDE INHALT DES DOC*****************

                    //überprüfen ob pro Fragestellung ein Dokument erstellt werden soll
                    //falls ja speichere das dokument bereits hier in der for-schleife und setze es danach zurück
                    if(manyFiles){
                        //Dateiname mit Nummer versehen
                        String path = exportPath.toString();
                        path = path.replace(".doc", "");
                        path = path  + "("+ i +")"+ ".doc";
                        File exportPathToMany = new File(path);
                        
                        //Doc speichern mit der entspechenden Nummer
                        try {
                            PrintWriter writer = new PrintWriter(exportPathToMany);
                            String output = myDoc.getContent();
                            output = output.replace("\u00f6", "oe");
                            output = output.replace("\u00d6", "Oe");
                            output = output.replace("\u00e4", "ae");
                            output = output.replace("\u00c4", "Ae");
                            output = output.replace("\u00fc", "ue");
                            output = output.replace("\u00dc", "Ue");
                            writer.println(output);
                            writer.close();
                            answer = true;
                        } 
                        //bei einem Fehler answer = false;
                        catch (Exception e) {
                            answer = false;
                        }
                        //setze myDoc zurück, damit es wieder leer ist und von der nächsten Frage befüllt werden kann
                        myDoc = new Document2004();
                        myDoc.encoding(Document2004.Encoding.UTF_8);
                        //Header
                        myDoc.getHeader().addEle(Paragraph.with("Yi Ching Export vom: " + new SimpleDateFormat("dd.MM.yyyy").format(new Date()) ).create());
                        //Footer
                        //leerer Footer damit PageNumber hineingeschrieben werden kann
                        myDoc.getFooter().addEle(Paragraph.with("").create());  
                        myDoc.getFooter().showPageNumber(true);
                    }

                    
                }
                
                //Falls nicht manyFiles speichere nun das .doc mit allen Fragestellungen darin
                if(!manyFiles){
                    try {
                        PrintWriter writer = new PrintWriter(exportPath);
                        String output = myDoc.getContent();
                            output = output.replace("\u00f6", "oe");
                            output = output.replace("\u00d6", "Oe");
                            output = output.replace("\u00e4", "ae");
                            output = output.replace("\u00c4", "Ae");
                            output = output.replace("\u00fc", "ue");
                            output = output.replace("\u00dc", "Ue");
                        writer.println(output);
                        writer.close();
                        answer = true;
                    } 
                    //bei einem Fehler answer = false
                    catch (Exception e) {
                        answer = false;
                    }
                }
                return answer;
                
	}
        
        /**
        * @author Schatzmann
        * Exportiert Fragen in ein oder Mehrere .csv Files
        * @param exportPath Pfad wo das/die .doc Files gespeichert werden
        * @param questionIndeces IntArray mit den ausgewählten Questions
        * @param manyFiles true heisst jede Fragestellung in ein eigenes .doc
        */
        public boolean exportQuestionToCsv(File exportPath, int[] questionIndeces, boolean manyFiles){
            //Rückgabewert answer
            boolean answer = false;
            
            //lese alle Selected QuestionCores aus und speichere Sie in der ArrayList<QuestionCore> selectedQuestionCores
            ArrayList<QuestionCore> selectedQuestionCores = new ArrayList<QuestionCore>();
            for(int selectedIndex : questionIndeces){
                    selectedQuestionCores.add(questionCoresUsed.get(selectedIndex));
            }
            
            //versuche zu exportieren, falls erfolgreich answer = true;
            try{
                //outputFile initialisieren
                PrintWriter outputFile = null;
                
                //falls nur ein File, erzeuge File vor der for schleife
                if(!manyFiles){
                  outputFile = new PrintWriter(new FileWriter(exportPath));  
                }
                

                //hole für jedes selectedQuestionCore die komplette Question und speichere diese im Question[] questionArray
                Question[] questionArray = new Question[selectedQuestionCores.size()];
                for(int i=0 ; i<questionArray.length; i++){
                    questionArray[i] = con.questionGet(selectedQuestionCores.get(i).getId());

                    //überprüfen ob pro Fragestellung ein Dokument erstellt werden soll
                    if(manyFiles){
                        //Dateiname mit Nummer versehen
                        String path = exportPath.toString();
                        path = path.replace(".csv", "");
                        path = path  + "("+ i +")"+ ".csv";
                        File exportPathToMany = new File(path);

                        //outputFile zürücksetzen, damit es wieder leer ist und von dieser Frage befüllt werden kann
                        //inkl. exportPfad mit nummer
                        outputFile = new PrintWriter(new FileWriter(exportPathToMany));
                    }

                    //Inhalt
                    int[] lineArray = questionArray[i].getLines();
                    String output = new String();
                    output = 
                        questionArray[i].getTitle() + ";"
                        + questionArray[i].getQuestion() + ";"
                        + questionArray[i].getAnalysis() + ";"
                        + questionArray[i].getSynthesis()+ ";"
                        + questionArray[i].getFeedback() + ";"
                        + lineArray[0] + ";"
                        + lineArray[1] + ";"
                        + lineArray[2] + ";"
                        + lineArray[3] + ";"
                        + lineArray[4] + ";"
                        + lineArray[5]
                        ; 
                            output = output.replace("\u00f6", "oe");
                            output = output.replace("\u00d6", "Oe");
                            output = output.replace("\u00e4", "ae");
                            output = output.replace("\u00c4", "Ae");
                            output = output.replace("\u00fc", "ue");
                            output = output.replace("\u00dc", "Ue");
                        outputFile.println(output);
                     //falls manyFiles dann schliesse das Dokument bereits hier ab
                     if(manyFiles){
                        outputFile.close();
                        answer = true;
                     }    
                }
                //falls !manyFiles dann schliesse das Dokument erst ausserhalb der for schleife ab
                if(!manyFiles){
                    outputFile.close();
                    answer = true;
                }
            }
            //falls nicht erfolgreich exportiert werden konnte, anwer = false;
            catch(Exception e){
                System.out.println(e);
                answer = false;
            }
            //Rückgabewert
            return answer;
        }
        
         /**
         * @author Schatzmann
         * Liest ein .csv File von einem angegebenen Pfad und speichert die enthaltenen Daten in der Datenbank
         * Verwendet die in der Methode exportQuestionToCsv erzeugen .csv Dateien
         * @param importPath Pfad wo sich die .csv Datei befindet
         * @param questionIndeces IntArray mit den ausgewählten Questions
         * @param manyFiles true heisst jede Fragestellung in ein eigenes .doc
         */
        public boolean importQuestionFromCsv(File importPath, int[] categorieIndeces){
            
            //rückgabewert answer
            boolean answer = false;
            //lese alle Selected QuestionCores aus und speichere Sie in der ArrayList<QuestionCore> selectedQuestionCores
            ArrayList<Category> selectedCategorys = new ArrayList<Category>();
            for(int selectedIndex : categorieIndeces){
                    selectedCategorys.add(categories.get(selectedIndex));
            }
            //Versuche zu importieren, falls erfolgreich answer = true
            try{         

                //create BufferedReader to read csv file
                BufferedReader br = new BufferedReader( new FileReader(importPath));
                String strLine = "";
                StringTokenizer st = null;
                String[] values = new String[11];
                //read comma separated file line by line
                while( (strLine = br.readLine()) != null){ 
                        //break comma separated line using ";"
                        st = new StringTokenizer(strLine, ";");
                        while(st.hasMoreTokens()){
                            //display csv values
                            for(int i=0 ; i<values.length; i++){
                                if(st.hasMoreTokens()){
                                    values[i] = st.nextToken();
                                }
                            }
                            //Erstelle eine neue Question mit den Daten aus dieser Zeile
                            Question question = new Question();

                                //Category aus dem Array lesen
                                question.setCat(selectedCategorys);
                                //Public standardmässig auf false
                                question.setIsPublic(false);
                                //Title
                                question.setTitle(values[0]);
                                //Question
                                question.setQuestion(values[1]);
                                //Analysis
                                question.setAnalysis(values[2]);
                                //Synthesis
                                question.setSynthesis(values[3]);
                                //Feedback
                                question.setFeedback(values[4]);
                                //Linien auslesen
                                int[] lineArray = new int[6];
                                lineArray[0] = Integer.parseInt(values[5]);
                                lineArray[1] = Integer.parseInt(values[6]);
                                lineArray[2] = Integer.parseInt(values[7]);
                                lineArray[3] = Integer.parseInt(values[8]);
                                lineArray[4] = Integer.parseInt(values[9]);
                                lineArray[5] = Integer.parseInt(values[10]);
                                //Linien setzen
                                question.setLines(lineArray);
                            //Question aus der .csv Zeile speichern
                            //answer je nach speicher erfolg
                            question = this.con.questionSave(question);
                            if(question==null){
                                answer = false;
                            }
                            else{
                                this.questionCoresAll.add(question);
                                answer = true;
                            }
 
                        }
                                

                               
                }       
            }
            catch(Exception e){
                    answer = false;
            }
            
            return answer;
        }
	
	// Autor Dilji
	// ********************************************************************************
	// Methoden Kategorieverwaltung
	// ********************************************************************************
	
    /**
     * Diese Methode ersetzt den Namen in der Kategorieliste an den mitgebenen Index
     * @param newNameToEdit neuer Name der Kategorie
     * @param indexToEdit Index der Kategorie, welche geaendert wird
     * @return Boolean ob der Name der Kategorie geaendert wurde
     */
	public Boolean editCategory(String newNameToEdit, int indexToEdit){
		
		// variabeln
		String newName = new String();
		String oldName = new String();  
		newName = newNameToEdit;
		oldName = this.getCategories().get(indexToEdit).getName();
		
		// neue Kategorie erstellen
		Category newCatName = this.getCategories().get(indexToEdit);
		newCatName.setName(newName);
		
		Category status = this.con.catSave(newCatName);
		
		if (status == null){
			this.getCategories().get(indexToEdit).setName(oldName);
			return false;
		} else {
			return true;
		}
	}
	
	/**
	 * Diese Methode loescht die Kategorie mit den uebergebenen Index
	 * @param indexToDel Index welche Kategorie zu loeschen ist
	 * @return Boolean ob die Kategorie geloescht wurde
	 */
	public boolean delCategory(int indexToDel){
		boolean re = false;
		
		re = con.catDelete(getCategories().get(indexToDel).getId());
		// remove aus arrayList
		if (re){
			this.getCategories().remove(indexToDel);
		}
		return re;
	}
}
